package com.teacher.game.framework.animation;

import java.util.ArrayList;
import java.util.List;

/**
 * 动画集合管理器
 * 
 * 支持多个UI动画的组合播放，提供同时播放和顺序播放两种模式。
 * 可以管理复杂的动画序列，如菜单切换、界面过渡等场景。
 * 
 * 支持的播放模式：
 * - TOGETHER：所有动画同时播放
 * - SEQUENTIALLY：按添加顺序依次播放
 * 
 * 核心特性：
 * - 动画组合：支持同时管理多个UIAnimator
 * - 播放模式：同步播放和顺序播放
 * - 生命周期：完整的启动/暂停/停止控制
 * - 事件回调：整体动画的开始和结束通知
 * 
 * 使用示例：
 * <pre>
 * AnimationSet set = new AnimationSet(AnimationSet.TOGETHER)
 *     .addAnimation(buttonFadeIn)
 *     .addAnimation(titleSlideIn)
 *     .setOnAnimationEndListener(() -> Log.d("Anim", "菜单动画完成"))
 *     .start();
 * </pre>
 * 
 * @version 1.0
 * @since 2025-09-12
 */
public class AnimationSet {
    
    /**
     * 播放模式枚举
     */
    public static final int TOGETHER = 0;       // 同时播放
    public static final int SEQUENTIALLY = 1;  // 顺序播放
    
    /**
     * 动画集合监听器
     */
    public interface AnimationSetListener {
        default void onAnimationSetStart(AnimationSet animationSet) {}
        default void onAnimationSetEnd(AnimationSet animationSet) {}
        default void onAnimationSetCancel(AnimationSet animationSet) {}
    }
    
    // 核心属性
    private List<UIAnimator> animators;        // 动画器列表
    private int playMode;                      // 播放模式
    private UIAnimator.State currentState;     // 当前状态
    
    // 顺序播放相关
    private int currentAnimatorIndex;          // 当前播放的动画索引
    
    // 监听器
    private AnimationSetListener listener;
    
    /**
     * 构造动画集合管理器
     * 
     * @param playMode 播放模式（TOGETHER或SEQUENTIALLY）
     */
    public AnimationSet(int playMode) {
        this.playMode = playMode;
        this.animators = new ArrayList<>();
        this.currentState = UIAnimator.State.IDLE;
        this.currentAnimatorIndex = 0;
    }
    
    /**
     * 添加动画到集合中
     * 
     * @param animator UI动画器
     * @return 当前动画集合（支持链式调用）
     */
    public AnimationSet addAnimation(UIAnimator animator) {
        if (animator == null) {
            throw new IllegalArgumentException("动画器不能为null");
        }
        
        animators.add(animator);
        
        // 为顺序播放模式设置动画结束监听器
        if (playMode == SEQUENTIALLY) {
            setupSequentialListener(animator);
        }
        
        return this;
    }
    
    /**
     * 设置动画集合监听器
     * 
     * @param listener 监听器
     * @return 当前动画集合
     */
    public AnimationSet setAnimationSetListener(AnimationSetListener listener) {
        this.listener = listener;
        return this;
    }
    
    /**
     * 启动动画集合
     * 
     * @return 当前动画集合
     */
    public AnimationSet start() {
        if (animators.isEmpty()) {
            return this;
        }
        
        currentState = UIAnimator.State.RUNNING;
        
        if (playMode == TOGETHER) {
            startTogetherMode();
        } else {
            startSequentialMode();
        }
        
        if (listener != null) {
            listener.onAnimationSetStart(this);
        }
        
        return this;
    }
    
    /**
     * 暂停所有动画
     */
    public void pause() {
        if (currentState != UIAnimator.State.RUNNING) {
            return;
        }
        
        currentState = UIAnimator.State.PAUSED;
        
        for (UIAnimator animator : animators) {
            animator.pause();
        }
    }
    
    /**
     * 恢复所有动画
     */
    public void resume() {
        if (currentState != UIAnimator.State.PAUSED) {
            return;
        }
        
        currentState = UIAnimator.State.RUNNING;
        
        for (UIAnimator animator : animators) {
            animator.resume();
        }
    }
    
    /**
     * 停止所有动画
     */
    public void stop() {
        currentState = UIAnimator.State.FINISHED;
        
        for (UIAnimator animator : animators) {
            animator.stop();
        }
        
        if (listener != null) {
            listener.onAnimationSetCancel(this);
        }
    }
    
    /**
     * 更新动画集合状态
     * 
     * @param deltaTime 时间增量（秒）
     */
    public void update(float deltaTime) {
        if (currentState != UIAnimator.State.RUNNING) {
            return;
        }
        
        if (playMode == TOGETHER) {
            updateTogetherMode(deltaTime);
        } else {
            updateSequentialMode(deltaTime);
        }
    }
    
    /**
     * 启动同时播放模式
     */
    private void startTogetherMode() {
        // 同时启动所有动画
        for (UIAnimator animator : animators) {
            animator.start();
        }
        
        // 设置结束监听器
        setupTogetherEndListener();
    }
    
    /**
     * 启动顺序播放模式
     */
    private void startSequentialMode() {
        currentAnimatorIndex = 0;
        if (currentAnimatorIndex < animators.size()) {
            animators.get(currentAnimatorIndex).start();
        }
    }
    
    /**
     * 更新同时播放模式
     */
    private void updateTogetherMode(float deltaTime) {
        for (UIAnimator animator : animators) {
            animator.update(deltaTime);
        }
    }
    
    /**
     * 更新顺序播放模式
     */
    private void updateSequentialMode(float deltaTime) {
        if (currentAnimatorIndex < animators.size()) {
            UIAnimator currentAnimator = animators.get(currentAnimatorIndex);
            currentAnimator.update(deltaTime);
        }
    }
    
    /**
     * 设置同时播放模式的结束监听器
     */
    private void setupTogetherEndListener() {
        final int[] finishedCount = {0}; // 使用数组来绕过final限制
        final int totalCount = animators.size();
        
        for (UIAnimator animator : animators) {
            animator.setAnimationListener(new UIAnimator.AnimationListener() {
                @Override
                public void onAnimationEnd(UIAnimator animator) {
                    finishedCount[0]++;
                    if (finishedCount[0] >= totalCount) {
                        // 所有动画都完成了
                        currentState = UIAnimator.State.FINISHED;
                        if (listener != null) {
                            listener.onAnimationSetEnd(AnimationSet.this);
                        }
                    }
                }
                
                @Override
                public void onAnimationCancel(UIAnimator animator) {
                    // 如果有动画被取消，整个集合也标记为结束
                    currentState = UIAnimator.State.FINISHED;
                    if (listener != null) {
                        listener.onAnimationSetCancel(AnimationSet.this);
                    }
                }
            });
        }
    }
    
    /**
     * 为顺序播放设置监听器
     */
    private void setupSequentialListener(UIAnimator animator) {
        animator.setAnimationListener(new UIAnimator.AnimationListener() {
            @Override
            public void onAnimationEnd(UIAnimator finishedAnimator) {
                // 启动下一个动画
                currentAnimatorIndex++;
                if (currentAnimatorIndex < animators.size()) {
                    animators.get(currentAnimatorIndex).start();
                } else {
                    // 所有动画都完成了
                    currentState = UIAnimator.State.FINISHED;
                    if (listener != null) {
                        listener.onAnimationSetEnd(AnimationSet.this);
                    }
                }
            }
            
            @Override
            public void onAnimationCancel(UIAnimator animator) {
                currentState = UIAnimator.State.FINISHED;
                if (listener != null) {
                    listener.onAnimationSetCancel(AnimationSet.this);
                }
            }
        });
    }
    
    // Getter方法
    public int getPlayMode() { return playMode; }
    public UIAnimator.State getCurrentState() { return currentState; }
    public boolean isRunning() { return currentState == UIAnimator.State.RUNNING; }
    public boolean isFinished() { return currentState == UIAnimator.State.FINISHED; }
    public int getAnimatorCount() { return animators.size(); }
    
    /**
     * 获取指定索引的动画器
     * 
     * @param index 索引
     * @return UI动画器
     */
    public UIAnimator getAnimator(int index) {
        if (index < 0 || index >= animators.size()) {
            throw new IndexOutOfBoundsException("动画器索引越界: " + index);
        }
        return animators.get(index);
    }
    
    /**
     * 重置所有动画到初始状态
     */
    public void reset() {
        currentState = UIAnimator.State.IDLE;
        currentAnimatorIndex = 0;
        
        for (UIAnimator animator : animators) {
            animator.reset();
        }
    }
    
    /**
     * 清空所有动画
     */
    public void clear() {
        stop();
        animators.clear();
        currentAnimatorIndex = 0;
    }
}